Cloning catalog objects

ABSTRACT

Example systems and methods for cloning catalog objects are described. In one implementation, a method identifies an original catalog object associated with a set of data and creates a duplicate copy of the original catalog object without copying the data itself. The method allows access to the set of data using the duplicate catalog object and supports modifying the data associated with the original catalog object independently of the duplicate catalog object. The duplicate catalog object can be deleted upon completion of modifying the data associated with the original catalog object.

CROSS REFERENCE TO RELATED APPLICATIONS

This application is a continuation-in-part of U.S. patent applicationSer. No. 14/518,884, entitled “Resource management systems and methods,”filed on Oct. 20, 2014, the disclosure of which is incorporated hereinby reference in its entirety. That application claims the benefit ofU.S. Provisional Application Ser. No. 61/941,986, entitled “Apparatusand method for enterprise data warehouse data processing on cloudinfrastructure,” filed Feb. 19, 2014, the disclosure of which is alsoincorporated herein by reference in its entirety.

TECHNICAL FIELD

The present disclosure relates to systems and methods that support datastorage and retrieval.

BACKGROUND

Many existing data storage and retrieval systems are available today.For example, in a shared-disk system, all data is stored on a sharedstorage device that is accessible from all of the processing nodes in adata cluster. In this type of system, all data changes are written tothe shared storage device to ensure that all processing nodes in thedata cluster access a consistent version of the data. As the number ofprocessing nodes increases in a shared-disk system, the shared storagedevice (and the communication links between the processing nodes and theshared storage device) becomes a bottleneck that slows data read anddata write operations. This bottleneck is further aggravated with theaddition of more processing nodes. Thus, existing shared-disk systemshave limited scalability due to this bottleneck problem.

Another existing data storage and retrieval system is referred to as a“shared-nothing architecture.” In this architecture, data is distributedacross multiple processing nodes such that each node stores a subset ofthe data in the entire database. When a new processing node is added orremoved, the shared-nothing architecture must rearrange data across themultiple processing nodes. This rearrangement of data can betime-consuming and disruptive to data read and write operations executedduring the data rearrangement. And, the affinity of data to a particularnode can create “hot spots” on the data cluster for popular data.Further, since each processing node performs also the storage function,this architecture requires at least one processing node to store data.Thus, the shared-nothing architecture fails to store data if allprocessing nodes are removed. Additionally, management of data in ashared-nothing architecture is complex due to the distribution of dataacross many different processing nodes.

The systems and methods described herein provide an improved approach todata storage and data retrieval that alleviates the above-identifiedlimitations of existing systems.

BRIEF DESCRIPTION OF THE DRAWINGS

Non-limiting and non-exhaustive embodiments of the present disclosureare described with reference to the following figures, wherein likereference numerals refer to like parts throughout the various figuresunless otherwise specified.

FIG. 1 is a block diagram depicting an example embodiment of the systemsand methods described herein.

FIG. 2 is a block diagram depicting an embodiment of a resource manager.

FIG. 3 is a block diagram depicting an embodiment of an executionplatform.

FIG. 4 is a block diagram depicting an example operating environmentwith multiple users accessing multiple databases through multiplevirtual warehouses.

FIG. 5 is a block diagram depicting another example operatingenvironment with multiple users accessing multiple databases through aload balancer and multiple virtual warehouses contained in a virtualwarehouse group.

FIG. 6 is a block diagram depicting another example operatingenvironment having multiple distributed virtual warehouses and virtualwarehouse groups.

FIG. 7 is a flow diagram depicting an embodiment of a method formanaging data storage and retrieval operations.

FIG. 8 is a flow diagram depicting an embodiment of a method for cloningcatalog objects.

FIG. 9 is a flow diagram depicting an embodiment of a method forcreating a temporary duplicate catalog object.

FIGS. 10A-10D depict an embodiment of an original table object and acloned table object accessing multiple files.

FIG. 11 is a block diagram depicting an example computing device.

DETAILED DESCRIPTION

The systems and methods described herein provide a new platform forstoring and retrieving data without the problems faced by existingsystems. For example, this new platform supports the addition of newnodes without the need for rearranging data files as required by theshared-nothing architecture. Additionally, nodes can be added to theplatform without creating bottlenecks that are common in the shared-disksystem. This new platform is always available for data read and datawrite operations, even when some of the nodes are offline formaintenance or have suffered a failure. The described platform separatesthe data storage resources from the computing resources so that data canbe stored without requiring the use of dedicated computing resources.This is an improvement over the shared-nothing architecture, which failsto store data if all computing resources are removed. Therefore, the newplatform continues to store data even though the computing resources areno longer available or are performing other tasks.

As described in more detail below, the described systems and methodsupport the copying of large amounts of data stored in databasewarehouses. A cloning technique is used to create new objects related toa copy of the data without actually copying the data itself. Thiscloning technique simplifies the process of updating large batches ofdata and experimenting with specific sets of data. In particular, thedescribed systems and methods are capable of identifying an originalcatalog object associated with a set of data and creating a duplicatecopy of the original catalog object without copying the data itself. Thesystems allow access to the set of data in the data storage system usingthe duplicate catalog object. The data associated with the originalcatalog object can be modified independently of the duplicate catalogobject. After the data associated with the original catalog object hasbeen modified, the system may delete the duplicate catalog object ordelete the original catalog object. As discussed herein, example catalogobjects include a database instance including metadata that definesdatabase objects such as schemas, tables, views, columns, constraints,sequences, functions, file formats, stages, and the like. Other examplecatalog objects may contain any type of data or data structures. Whendiscussing various systems and methods, a “catalog object” may also bereferred to as a “schema object.”

In the following description, reference is made to the accompanyingdrawings that form a part thereof, and in which is shown by way ofillustration specific exemplary embodiments in which the disclosure maybe practiced. These embodiments are described in sufficient detail toenable those skilled in the art to practice the concepts disclosedherein, and it is to be understood that modifications to the variousdisclosed embodiments may be made, and other embodiments may beutilized, without departing from the scope of the present disclosure.The following detailed description is, therefore, not to be taken in alimiting sense.

Reference throughout this specification to “one embodiment,” “anembodiment,” “one example” or “an example” means that a particularfeature, structure or characteristic described in connection with theembodiment or example is included in at least one embodiment of thepresent disclosure. Thus, appearances of the phrases “in oneembodiment,” “in an embodiment,” “one example” or “an example” invarious places throughout this specification are not necessarily allreferring to the same embodiment or example. In addition, it should beappreciated that the figures provided herewith are for explanationpurposes to persons ordinarily skilled in the art and that the drawingsare not necessarily drawn to scale.

Embodiments in accordance with the present disclosure may be embodied asan apparatus, method or computer program product. Accordingly, thepresent disclosure may take the form of an entirely hardware-comprisedembodiment, an entirely software-comprised embodiment (includingfirmware, resident software, micro-code, etc.) or an embodimentcombining software and hardware aspects that may all generally bereferred to herein as a “circuit,” “module” or “system.” Furthermore,embodiments of the present disclosure may take the form of a computerprogram product embodied in any tangible medium of expression havingcomputer-usable program code embodied in the medium.

Any combination of one or more computer-usable or computer-readablemedia may be utilized. For example, a computer-readable medium mayinclude one or more of a portable computer diskette, a hard disk, arandom access memory (RAM) device, a read-only memory (ROM) device, anerasable programmable read-only memory (EPROM or Flash memory) device, aportable compact disc read-only memory (CDROM), an optical storagedevice, and a magnetic storage device. Computer program code forcarrying out operations of the present disclosure may be written in anycombination of one or more programming languages. Such code may becompiled from source code to computer-readable assembly language ormachine code suitable for the device or computer on which the code willbe executed.

Embodiments may also be implemented in cloud computing environments. Inthis description and the following claims, “cloud computing” may bedefined as a model for enabling ubiquitous, convenient, on-demandnetwork access to a shared pool of configurable computing resources(e.g., networks, servers, storage, applications, and services) that canbe rapidly provisioned via virtualization and released with minimalmanagement effort or service provider interaction and then scaledaccordingly. A cloud model can be composed of various characteristics(e.g., on-demand self-service, broad network access, resource pooling,rapid elasticity, and measured service), service models (e.g., Softwareas a Service (“SaaS”), Platform as a Service (“PaaS”), andInfrastructure as a Service (“IaaS”)), and deployment models (e.g.,private cloud, community cloud, public cloud, and hybrid cloud).

The flow diagrams and block diagrams in the attached figures illustratethe architecture, functionality, and operation of possibleimplementations of systems, methods, and computer program productsaccording to various embodiments of the present disclosure. In thisregard, each block in the flow diagrams or block diagrams may representa module, segment, or portion of code, which comprises one or moreexecutable instructions for implementing the specified logicalfunction(s). It will also be noted that each block of the block diagramsand/or flow diagrams, and combinations of blocks in the block diagramsand/or flow diagrams, may be implemented by special purposehardware-based systems that perform the specified functions or acts, orcombinations of special purpose hardware and computer instructions.These computer program instructions may also be stored in acomputer-readable medium that can direct a computer or otherprogrammable data processing apparatus to function in a particularmanner, such that the instructions stored in the computer-readablemedium produce an article of manufacture including instruction meanswhich implement the function/act specified in the flow diagram and/orblock diagram block or blocks.

The systems and methods described herein provide a flexible and scalabledata warehouse using a new data processing platform. In someembodiments, the described systems and methods leverage a cloudinfrastructure that supports cloud-based storage resources, computingresources, and the like. Example cloud-based storage resources offersignificant storage capacity available on-demand at a low cost. Further,these cloud-based storage resources may be fault-tolerant and highlyscalable, which can be costly to achieve in private data storagesystems. Example cloud-based computing resources are available on-demandand may be priced based on actual usage levels of the resources.Typically, the cloud infrastructure is dynamically deployed,reconfigured, and decommissioned in a rapid manner.

In the described systems and methods, a data storage system utilizes anSQL (Structured Query Language)-based relational database. However,these systems and methods are applicable to any type of database, andany type of data storage and retrieval platform, using any data storagearchitecture and using any language to store and retrieve data withinthe data storage and retrieval platform. The systems and methodsdescribed herein further provide a multi-tenant system that supportsisolation of computing resources and data between differentcustomers/clients and between different users within the samecustomer/client.

FIG. 1 is a block diagram depicting an example embodiment of a new dataprocessing platform 100. As shown in FIG. 1, a resource manager 102 iscoupled to multiple users 104, 106, and 108. In particularimplementations, resource manager 102 can support any number of usersdesiring access to data processing platform 100. Users 104-108 mayinclude, for example, end users providing data storage and retrievalrequests, system administrators managing the systems and methodsdescribed herein, and other components/devices that interact withresource manager 102. Resource manager 102 provides various services andfunctions that support the operation of all systems and componentswithin data processing platform 100. As used herein, resource manager102 may also be referred to as a “global services system” that performsvarious functions as discussed herein.

Resource manager 102 is also coupled to metadata 110, which isassociated with the entirety of data stored throughout data processingplatform 100. In some embodiments, metadata 110 includes a catalog ofdata stored in remote data storage systems as well as data availablefrom a local cache. In particular embodiments, the catalog of datastored in the remote data storage systems includes a summary of datastored in the remote data storage systems. Additionally, metadata 110may include information regarding how data is organized in the remotedata storage systems and the local caches. Metadata 110 allows systemsand services to determine whether a piece of data needs to be accessedwithout loading or accessing the actual data from a storage device.

Resource manager 102 is further coupled to an execution platform 112,which provides multiple computing resources that execute various datastorage and data retrieval tasks, as discussed in greater detail below.Execution platform 112 is coupled to multiple data storage devices 116,118, and 120 that are part of a storage platform 114. Although threedata storage devices 116, 118, and 120 are shown in FIG. 1, executionplatform 112 is capable of communicating with any number of data storagedevices. In some embodiments, data storage devices 116, 118, and 120 arecloud-based storage devices located in one or more geographic locations.For example, data storage devices 116, 118, and 120 may be part of apublic cloud infrastructure or a private cloud infrastructure. Datastorage devices 116, 118, and 120 may be hard disk drives (HDDs), solidstate drives (SSDs), storage clusters, Amazon S3™ storage systems or anyother data storage technology. Additionally, storage platform 114 mayinclude distributed file systems (such as Hadoop Distributed FileSystems (HDFS)), object storage systems, and the like.

In particular embodiments, the communication links between resourcemanager 102 and users 104-108, metadata 110, and execution platform 112are implemented via one or more data communication networks. Similarly,the communication links between execution platform 112 and data storagedevices 116-120 in storage platform 114 are implemented via one or moredata communication networks. These data communication networks mayutilize any communication protocol and any type of communication medium.In some embodiments, the data communication networks are a combinationof two or more data communication networks (or sub-networks) coupled toone another. In alternate embodiments, these communication links areimplemented using any type of communication medium and any communicationprotocol.

As shown in FIG. 1, data storage devices 116, 118, and 120 are decoupledfrom the computing resources associated with execution platform 112.This architecture supports dynamic changes to data processing platform100 based on the changing data storage/retrieval needs as well as thechanging needs of the users and systems accessing data processingplatform 100. The support of dynamic changes allows data processingplatform 100 to scale quickly in response to changing demands on thesystems and components within data processing platform 100. Thedecoupling of the computing resources from the data storage devicessupports the storage of large amounts of data without requiring acorresponding large amount of computing resources. Similarly, thisdecoupling of resources supports a significant increase in the computingresources utilized at a particular time without requiring acorresponding increase in the available data storage resources.

Resource manager 102, metadata 110, execution platform 112, and storageplatform 114 are shown in FIG. 1 as individual components. However, eachof resource manager 102, metadata 110, execution platform 112, andstorage platform 114 may be implemented as a distributed system (e.g.,distributed across multiple systems/platforms at multiple geographiclocations). Additionally, each of resource manager 102, metadata 110,execution platform 112, and storage platform 114 can be scaled up ordown (independently of one another) depending on changes to the requestsreceived from users 104-108 and the changing needs of data processingplatform 100. Thus, in the described embodiments, data processingplatform 100 is dynamic and supports regular changes to meet the currentdata processing needs.

During typical operation, data processing platform 100 processesmultiple queries (or requests) received from any of the users 104-108.These queries are managed by resource manager 102 to determine when andhow to execute the queries. For example, resource manager 102 maydetermine what data is needed to process the query and further determinewhich nodes within execution platform 112 are best suited to process thequery. Some nodes may have already cached the data needed to process thequery and, therefore, are good candidates for processing the query.Metadata 110 assists resource manager 102 in determining which nodes inexecution platform 112 already cache at least a portion of the dataneeded to process the query. One or more nodes in execution platform 112process the query using data cached by the nodes and, if necessary, dataretrieved from storage platform 114. It is desirable to retrieve as muchdata as possible from caches within execution platform 112 because theretrieval speed is typically much faster than retrieving data fromstorage platform 114.

As shown in FIG. 1, data processing platform 100 separates executionplatform 112 from storage platform 114. In this arrangement, theprocessing resources and cache resources in execution platform 112operate independently of the data storage resources 116-120 in storageplatform 114. Thus, the computing resources and cache resources are notrestricted to specific data storage resources 116-120. Instead, allcomputing resources and all cache resources may retrieve data from, andstore data to, any of the data storage resources in storage platform114. Additionally, data processing platform 100 supports the addition ofnew computing resources and cache resources to execution platform 112without requiring any changes to storage platform 114. Similarly, dataprocessing platform 100 supports the addition of data storage resourcesto storage platform 114 without requiring any changes to nodes inexecution platform 112.

FIG. 2 is a block diagram depicting an embodiment of resource manager102. As shown in FIG. 2, resource manager 102 includes an access manager202 and a key manager 204 coupled to a data storage device 206. Accessmanager 202 handles authentication and authorization tasks for thesystems described herein. Key manager 204 manages storage andauthentication of keys used during authentication and authorizationtasks. For example, access manager 202 and key manager 204 manage thekeys used to access data stored in remote storage devices (e.g., datastorage devices in storage platform 114). As used herein, the remotestorage devices may also be referred to as “persistent storage devices.”A request processing service 208 manages received data storage requestsand data retrieval requests (e.g., database queries). For example,request processing service 208 may determine the data necessary toprocess the received data storage request or data retrieval request. Thenecessary data may be stored in a cache within execution platform 112(as discussed in greater detail below) or in a data storage device instorage platform 114. A management console service 210 supports accessto various systems and processes by administrators and other systemmanagers. Additionally, management console service 210 may receiverequests from users 104-108 to issue queries and monitor the workload onthe system. In some embodiments, a particular user may issue a requestto monitor the workload that their specific query places on the system.

Resource manager 102 also includes an SQL compiler 212, an SQL optimizer214 and an SQL executor 210. SQL compiler 212 parses SQL queries andgenerates the execution code for the queries. SQL optimizer 214determines the best method to execute queries based on the data thatneeds to be processed. SQL optimizer 214 also handles various datapruning operations and other data optimization techniques to improve thespeed and efficiency of executing the SQL query. SQL executor 216executes the query code for queries received by resource manager 102.

A query scheduler and coordinator 218 sends received queries to theappropriate services or systems for compilation, optimization, anddispatch to execution platform 112. For example, queries may beprioritized and processed in that prioritized order. In someembodiments, query scheduler and coordinator 218 identifies or assignsparticular nodes in execution platform 112 to process particularqueries. A virtual warehouse manager 220 manages the operation ofmultiple virtual warehouses implemented in execution platform 112. Asdiscussed below, each virtual warehouse includes multiple executionnodes that each include a cache and a processor.

Additionally, resource manager 102 includes a configuration and metadatamanager 222, which manages the information related to the data stored inthe remote data storage devices and in the local caches (i.e., thecaches in execution platform 112). As discussed in greater detail below,configuration and metadata manager 222 uses the metadata to determinewhich data files need to be accessed to retrieve data for processing aparticular query. A monitor and workload analyzer 224 oversees theprocesses performed by resource manager 102 and manages the distributionof tasks (e.g., workload) across the virtual warehouses and executionnodes in execution platform 112. Monitor and workload analyzer 224 alsoredistributes tasks, as needed, based on changing workloads throughoutdata processing platform 100. Configuration and metadata manager 222 andmonitor and workload analyzer 224 are coupled to a data storage device226. Data storage devices 206 and 226 in FIG. 2 represent any datastorage device within data processing platform 100. For example, datastorage devices 206 and 226 may represent caches in execution platform112, storage devices in storage platform 114, or any other storagedevice.

Resource manager 102 also includes a transaction management and accesscontrol module 228, which manages the various tasks and other activitiesassociated with the processing of data storage requests and data accessrequests. For example, transaction management and access control module228 provides consistent and synchronized access to data by multipleusers or systems. Since multiple users/systems may access the same datasimultaneously, changes to the data must be synchronized to ensure thateach user/system is working with the current version of the data.Transaction management and access control module 228 provides control ofvarious data processing activities at a single, centralized location inresource manager 102. In some embodiments, transaction management andaccess control module 228 interacts with SQL executor 216 to support themanagement of various tasks being executed by SQL executor 216.

FIG. 3 is a block diagram depicting an embodiment of an executionplatform 112. As shown in FIG. 3, execution platform 112 includesmultiple virtual warehouses 302, 304, and 306. Each virtual warehouseincludes multiple execution nodes that each include a data cache and aprocessor. Virtual warehouses 302, 304, and 306 are capable of executingmultiple queries (and other tasks) in parallel by using the multipleexecution nodes. As discussed herein, execution platform 112 can add newvirtual warehouses and drop existing virtual warehouses in real timebased on the current processing needs of the systems and users. Thisflexibility allows execution platform 112 to quickly deploy largeamounts of computing resources when needed without being forced tocontinue paying for those computing resources when they are no longerneeded. All virtual warehouses can access data from any data storagedevice (e.g., any storage device in storage platform 114).

Although each virtual warehouse 302-306 shown in FIG. 3 includes threeexecution nodes, a particular virtual warehouse may include any numberof execution nodes. Further, the number of execution nodes in a virtualwarehouse is dynamic, such that new execution nodes are created whenadditional demand is present, and existing execution nodes are deletedwhen they are no longer necessary.

Each virtual warehouse 302-306 is capable of accessing any of the datastorage devices 116-120 shown in FIG. 1. Thus, virtual warehouses302-306 are not necessarily assigned to a specific data storage device116-120 and, instead, can access data from any of the data storagedevices 116-120. Similarly, each of the execution nodes shown in FIG. 3can access data from any of the data storage devices 116-120. In someembodiments, a particular virtual warehouse or a particular executionnode may be temporarily assigned to a specific data storage device, butthe virtual warehouse or execution node may later access data from anyother data storage device.

In the example of FIG. 3, virtual warehouse 302 includes three executionnodes 308, 310, and 312. Execution node 308 includes a cache 314 and aprocessor 316. Execution node 310 includes a cache 318 and a processor320. Execution node 312 includes a cache 322 and a processor 324. Eachexecution node 308-312 is associated with processing one or more datastorage and/or data retrieval tasks. For example, a particular virtualwarehouse may handle data storage and data retrieval tasks associatedwith a particular user or customer. In other implementations, aparticular virtual warehouse may handle data storage and data retrievaltasks associated with a particular data storage system or a particularcategory of data.

Similar to virtual warehouse 302 discussed above, virtual warehouse 304includes three execution nodes 326, 328, and 330. Execution node 326includes a cache 332 and a processor 334. Execution node 328 includes acache 336 and a processor 338. Execution node 330 includes a cache 340and a processor 342. Additionally, virtual warehouse 306 includes threeexecution nodes 344, 346, and 348. Execution node 344 includes a cache350 and a processor 352. Execution node 346 includes a cache 354 and aprocessor 356. Execution node 348 includes a cache 358 and a processor360.

In some embodiments, the execution nodes shown in FIG. 3 are statelesswith respect to the data the execution nodes are caching. For example,these execution nodes do not store or otherwise maintain stateinformation about the execution node or the data being cached by aparticular execution node. Thus, in the event of an execution nodefailure, the failed node can be transparently replaced by another node.Since there is no state information associated with the failed executionnode, the new (replacement) execution node can easily replace the failednode without concern for recreating a particular state.

Although the execution nodes shown in FIG. 3 each include one data cacheand one processor, alternate embodiments may include execution nodescontaining any number of processors and any number of caches.Additionally, the caches may vary in size among the different executionnodes. The caches shown in FIG. 3 store, in the local execution node,data that was retrieved from one or more data storage devices in storageplatform 114 (FIG. 1). Thus, the caches reduce or eliminate thebottleneck problems occurring in platforms that consistently retrievedata from remote storage systems. Instead of repeatedly accessing datafrom the remote storage devices, the systems and methods describedherein access data from the caches in the execution nodes which issignificantly faster and avoids the bottleneck problem discussed above.In some embodiments, the caches are implemented using high-speed memorydevices that provide fast access to the cached data. Each cache canstore data from any of the storage devices in storage platform 114.

Further, the cache resources and computing resources may vary betweendifferent execution nodes. For example, one execution node may containsignificant computing resources and minimal cache resources, making theexecution node useful for tasks that require significant computingresources. Another execution node may contain significant cacheresources and minimal computing resources, making this execution nodeuseful for tasks that require caching of large amounts of data. Yetanother execution node may contain cache resources providing fasterinput-output operations, useful for tasks that require fast scanning oflarge amounts of data. In some embodiments, the cache resources andcomputing resources associated with a particular execution node aredetermined when the execution node is created, based on the expectedtasks to be performed by the execution node.

Additionally, the cache resources and computing resources associatedwith a particular execution node may change over time based on changingtasks performed by the execution node. For example, a particularexecution node may be assigned more processing resources if the tasksperformed by the execution node become more processor intensive.Similarly, an execution node may be assigned more cache resources if thetasks performed by the execution node require a larger cache capacity.

Although virtual warehouses 302-306 are associated with the sameexecution platform 112, the virtual warehouses may be implemented usingmultiple computing systems at multiple geographic locations. Forexample, virtual warehouse 302 can be implemented by a computing systemat a first geographic location, while virtual warehouses 304 and 306 areimplemented by another computing system at a second geographic location.In some embodiments, these different computing systems are cloud-basedcomputing systems maintained by one or more different entities.

Additionally, each virtual warehouse is shown in FIG. 3 as havingmultiple execution nodes. The multiple execution nodes associated witheach virtual warehouse may be implemented using multiple computingsystems at multiple geographic locations. For example, a particularinstance of virtual warehouse 302 implements execution nodes 308 and 310on one computing platform at a particular geographic location, andimplements execution node 312 at a different computing platform atanother geographic location. Selecting particular computing systems toimplement an execution node may depend on various factors, such as thelevel of resources needed for a particular execution node (e.g.,processing resource requirements and cache requirements), the resourcesavailable at particular computing systems, communication capabilities ofnetworks within a geographic location or between geographic locations,and which computing systems are already implementing other executionnodes in the virtual warehouse.

Execution platform 112 is also fault tolerant. For example, if onevirtual warehouse fails, that virtual warehouse is quickly replaced witha different virtual warehouse at a different geographic location.

A particular execution platform 112 may include any number of virtualwarehouses 302-306. Additionally, the number of virtual warehouses in aparticular execution platform is dynamic, such that new virtualwarehouses are created when additional processing and/or cachingresources are needed. Similarly, existing virtual warehouses may bedeleted when the resources associated with the virtual warehouse are nolonger necessary.

In some embodiments, virtual warehouses 302, 304, and 306 may operate onthe same data in storage platform 114, but each virtual warehouse hasits own execution nodes with independent processing and cachingresources. This configuration allows requests on different virtualwarehouses to be processed independently and with no interferencebetween the requests. This independent processing, combined with theability to dynamically add and remove virtual warehouses, supports theaddition of new processing capacity for new users without impacting theperformance observed by the existing users.

FIG. 4 is a block diagram depicting an example operating environment 400with multiple users accessing multiple databases through multiplevirtual warehouses. In environment 400, multiple users 402, 404, and 406access multiple databases 414, 416, 418, 420, 422, and 424 throughmultiple virtual warehouses 408, 410, and 412. Although not shown inFIG. 4, users 402, 404, and 406 may access virtual warehouses 408, 410,and 412 through resource manager 102 (FIG. 1). In particularembodiments, databases 414-424 are contained in storage platform 114(FIG. 1) and are accessible by any virtual warehouse implemented inexecution platform 112. In some embodiments, users 402-406 access one ofthe virtual warehouses 408-412 using a data communication network, suchas the Internet. In some implementations, each user 402-406 specifies aparticular virtual warehouse 408-412 to work with at a specific time. Inthe example of FIG. 4, user 402 interacts with virtual warehouse 408,user 404 interacts with virtual warehouse 410, and user 406 interactswith virtual warehouse 412. Thus, user 402 submits data retrieval anddata storage requests through virtual warehouse 408. Similarly, users404 and 406 submit data retrieval and data storage requests throughvirtual warehouses 410 and 412, respectively.

Each virtual warehouse 408-412 is configured to communicate with asubset of all databases 414-424. For example, in environment 400,virtual warehouse 408 is configured to communicate with databases 414,416, and 422. Similarly, virtual warehouse 410 is configured tocommunicate with databases 416, 418, 420, and 424. And, virtualwarehouse 412 is configured to communicate with databases 416, 422, and424. In alternate embodiments, one or more of virtual warehouses 408-412communicate with all of the databases 414-424. The arrangement shown inFIG. 4 allows individual users to send all data retrieval and datastorage requests through a single virtual warehouse. That virtualwarehouse processes the data retrieval and data storage tasks usingcached data within one of the execution nodes in the virtual warehouse,or retrieves (and caches) the necessary data from an appropriatedatabase. The mappings between the virtual warehouses is a logicalmapping, not a hardware mapping. This logical mapping is based on accesscontrol parameters related to security and resource access managementsettings. The logical mappings are easily changed without requiringreconfiguration of the virtual warehouse or storage resources.

Although environment 400 shows virtual warehouses 408-412 configured tocommunicate with specific subsets of databases 414-424, thatconfiguration is dynamic. For example, virtual warehouse 408 may bereconfigured to communicate with a different subset of databases 414-424based on changing tasks to be performed by virtual warehouse 408. Forinstance, if virtual warehouse 408 receives requests to access data fromdatabase 418, virtual warehouse 408 may be reconfigured to alsocommunicate with database 418. If, at a later time, virtual warehouse408 no longer needs to access data from database 418, virtual warehouse408 may be reconfigured to delete the communication with database 418.

FIG. 5 is a block diagram depicting another example operatingenvironment 500 with multiple users accessing multiple databases througha load balancer and multiple virtual warehouses contained in a virtualwarehouse group. Environment 500 is similar to environment 400 (FIG. 4),but additionally includes a virtual warehouse resource manager 508 andmultiple virtual warehouses 510, 512, and 514 arranged in a virtualwarehouse group 516. Virtual warehouse resource manager 508 may becontained in resource manager 102. In particular, multiple users 502,504, and 506 access multiple databases 518, 520, 522, 524, 526, and 528through virtual warehouse resource manager 508 and virtual warehousegroup 516. In some embodiments, users 502-506 access virtual warehouseresource manager 508 using a data communication network, such as theInternet. Although not shown in FIG. 5, users 502, 504, and 506 mayaccess virtual warehouse resource manager 508 through resource manager102 (FIG. 1). In some embodiments, virtual warehouse resource manager508 is implemented within resource manager 102.

Users 502-506 may submit data retrieval and data storage requests tovirtual warehouse resource manager 508, which routes the data retrievaland data storage requests to an appropriate virtual warehouse 510-514 invirtual warehouse group 516. In some implementations, virtual warehouseresource manager 508 provides a dynamic assignment of users 502-506 tovirtual warehouses 510-514. When submitting a data retrieval or datastorage request, users 502-506 may specify virtual warehouse group 516to process the request without specifying the particular virtualwarehouse 510-514 that will process the request. This arrangement allowsvirtual warehouse resource manager 508 to distribute multiple requestsacross the virtual warehouses 510-514 based on efficiency, availableresources, and the availability of cached data within the virtualwarehouses 510-514. When determining how to route data processingrequests, virtual warehouse resource manager 508 considers availableresources, current resource loads, number of current users, and thelike.

In some embodiments, fault tolerance systems create a new virtualwarehouses in response to a failure of a virtual warehouse. The newvirtual warehouse may be in the same virtual warehouse group or may becreated in a different virtual warehouse group at a different geographiclocation.

Each virtual warehouse 510-514 is configured to communicate with asubset of all databases 518-528. For example, in environment 500,virtual warehouse 510 is configured to communicate with databases 518,520, and 526. Similarly, virtual warehouse 512 is configured tocommunicate with databases 520, 522, 524, and 528. And, virtualwarehouse 514 is configured to communicate with databases 520, 526, and528. In alternate embodiments, virtual warehouses 510-514 maycommunicate with any (or all) of the databases 518-528.

Although environment 500 shows one virtual warehouse group 516,alternate embodiments may include any number of virtual warehousegroups, each associated with any number of virtual warehouses. Thenumber of virtual warehouse groups in a particular environment isdynamic and may change based on the changing needs of the users andother systems in the environment.

FIG. 6 is a block diagram depicting another example operatingenvironment 600 having multiple distributed virtual warehouses andvirtual warehouse groups. Environment 600 includes resource manager 102that communicates with virtual warehouse groups 604 and 606 through adata communication network 602. Warehouse group 604 includes two virtualwarehouses 608 and 610, and warehouse group 606 includes another twovirtual warehouses 614 and 616. Resource manager 102 also communicateswith virtual warehouse 612 (which is not part of a virtual warehousegroup) through data communication network 602.

Virtual warehouse groups 604 and 606 as well as virtual warehouse 612communicate with databases 620, 622, and 624 through a datacommunication network 618. In some embodiments data communicationnetworks 602 and 618 are the same network. Environment 600 allowsresource manager 102 to coordinate user data storage and retrievalrequests across the multiple virtual warehouses 608-616 to store andretrieve data in databases 620-624. Virtual warehouse groups 604 and 606can be located in the same geographic area, or can be separatedgeographically. Additionally, virtual warehouse groups 604 and 606 canbe implemented by the same entity or by different entities.

The systems and methods described herein allow data to be stored andaccessed as a service that is separate from computing (or processing)resources. Even if no computing resources have been allocated from theexecution platform, data is available to a virtual warehouse withoutrequiring reloading of the data from a remote data source. Thus, data isavailable independently of the allocation of computing resourcesassociated with the data. The described systems and methods are usefulwith any type of data. In particular embodiments, data is stored in astructured, optimized format. The decoupling of the data storage/accessservice from the computing services also simplifies the sharing of dataamong different users and groups. As discussed herein, each virtualwarehouse can access any data to which it has access permissions, evenat the same time as other virtual warehouses are accessing the samedata. This architecture supports running queries without any actual datastored in the local cache. The systems and methods described herein arecapable of transparent dynamic data movement, which moves data from aremote storage device to a local cache, as needed, in a manner that istransparent to the user of the system. Further, this architecturesupports data sharing without prior data movement since any virtualwarehouse can access any data due to the decoupling of the data storageservice from the computing service.

FIG. 7 is a flow diagram depicting an embodiment of a method 700 formanaging data storage and retrieval operations. Initially, method 700receives a statement, request or query from a user at 702. A statementis any request or command to perform a data-related operation. Examplestatements include data retrieval requests, data storage requests, datatransfer requests, data queries, and the like. In some embodiments, thestatement is implemented as an SQL statement. A resource manager createsa query coordinator at 704 to manage the received statement. Forexample, the query coordinator manages the various tasks necessary toprocess the received statement, including interacting with an executionplatform and one or more data storage devices. In some embodiments, thequery coordinator is a temporary routine created specifically to managethe received statement.

Method 700 continues as the resource manager determines multiple tasksnecessary to process the received statement at 706. The multiple tasksmay include, for example, accessing data from a cache in an executionnode, retrieving data from a remote storage device, updating data in acache, storing data in a remote storage device, and the like. Theresource manager also distributes the multiple tasks to execution nodesin the execution platform at 708. As discussed herein, the executionnodes in the execution platform are implemented within virtualwarehouses. Each execution node performs an assigned task and returns atask result to the resource manager at 710. In some embodiments, theexecution nodes return the task results to the query coordinator. Theresource manager receives the multiple task results and creates astatement result at 712, and communicates the statement result to theuser at 714. In some embodiments, the query coordinator is deleted afterthe statement result is communicated to the user.

In some implementations, the same file is cached by multiple executionnodes at the same time. This multiple caching of files helps with loadbalancing (e.g., balancing data processing tasks) across multipleexecution nodes. Additionally, caching a file in multiple executionnodes helps avoid potential bottlenecks when significant amounts of dataare trying to pass through the same communication link. Thisimplementation also supports the parallel processing of the same data bydifferent execution nodes.

The systems and methods described herein take advantage of the benefitsof both shared-disk systems and the shared-nothing architecture. Thedescribed platform for storing and retrieving data is scalable like theshared-nothing architecture once data is cached locally. It also has allthe benefits of a shared-disk architecture where processing nodes can beadded and removed without any constraints (e.g., for 0 to N) and withoutrequiring any explicit reshuffling of data.

In previous data management systems, copying large amounts of data in adata warehouse was time consuming and required significant resources tomaintain and process multiple copies of the same data. Additionally,data inconsistencies exist in these previous systems while the data isbeing copied and changes are applied to one of the sets of data.

However, the systems and methods described herein for cloning catalogobjects generate a new catalog object which is activated quickly and isindependent of the original catalog object. As discussed below, the newcatalog object is created without duplicating the data associated withthe catalog object. Instead, only the metadata associated with thecatalog object is copied, which is significantly faster than attemptingto copy the data itself. For example, by copying only the metadataassociated with a catalog object may be several orders of magnitudefaster than copying all of the data. In an example situation, 1 KB ofmetadata is copied instead of 1 MB of actual data.

As used herein, a table is a logical grouping of data and a schema is aset of tables. Example catalog objects include, for example, a table, adatabase, a schema, an account, a constraint, a file format, a function,a role, a sequence, a stage, a column, a user, and a volume. Thefollowing hierarchy represents an example hierarchy of objects used withthe systems and methods described herein.

account - database - schema - table/view/sequence - columns/constraintsaccount - database - schema - function/file format/stage account - useraccount - role account - volume account - warehouse

In some embodiments, these catalog objects are defined by the SQLstandard. As discussed herein, a table contains multiple rows andcolumns. A schema contains any number of tables, and a database containsany number of schemas. The systems and methods described herein arecapable of cloning tables, schemas and databases. In someimplementations, individual tables may be cloned, while otherimplementations may clone entire databases, depending on the dataoperations being performed. Additionally, a cloning operation may cloneall generations of children under a root catalog object. Since a clonedhigher level object is independent of the original object, new childcatalog objects can be added to the cloned object (or cloned childcatalog objects can be removed from the cloned object) without affectingthe original higher level object and its hierarchy.

Cloning a catalog object creates a new catalog object of the same typequickly and without creating an additional copy of the data. Forexample, if a database is being cloned, the cloning process creates anew database object and all the tables and schemas and other catalogobjects under that database object, but does not copy the data containedin the database. After the cloning process is finished, the clonedcatalog object and the original catalog object can be modifiedindependently of one another. Additionally, objects can be added to andremoved from each copy of the catalog object as well as the originalcatalog object.

FIG. 8 is a flow diagram depicting an embodiment of a method for cloningcatalog objects. Initially, method 800 identifies a database to becloned at 802. This database may contain any number of schemas. Method800 continues by identifying multiple schemas associated with thedatabase at 804 and selecting one of the identified schemas at 806. Themethod then identifies multiple tables and other catalog objectsassociated with the selected schema at 808. One of the identified tablesis selected at 810 and all metadata associated with the selected tableis identified at 812. In some embodiments, this metadata includes asummary of data stored in the database. As discussed herein, themetadata may include information regarding how data is organized in thedatabase, tables or other storage mechanisms. The metadata allows thesystems and methods discussed herein to determine information aboutstored data without loading or accessing the actual data from a storagedevice.

Method 800 clones the selected table at 814 by copying the metadataassociated with the selected table. This copying of metadata isperformed quickly as compared to the time necessary to copy all of thedata associated with the metadata. After the table is cloned at 814, themethod determines whether there are additional tables in the selectedschema that need to be cloned at 816. If additional tables remain to becloned, method 800 returns to 810 to select the next table in theschema. If all tables in the selected schema have been cloned, themethod determines at 818 whether there are additional schemas in theidentified database to be cloned. If additional schemas remain to becloned, method 800 returns to 806 to select the next schema in thedatabase. This recursive operation ensures that all tables in allschemas of the identified database are cloned. After all schemas in theidentified database have been cloned, the original database, itsschemas, tables, and other child catalog objects can be modifiedindependently of the cloned database at 820.

In some embodiments, data in the cloned tables is used for current dataaccess requests while data in the original tables is modified. When themodifications of the original tables are complete, the cloned tables aredeleted and all data access requests are handled using the originaltables. In these embodiments, the copying of metadata without copyingthe actual underlying data, significantly increases the speed of thedata modification process and reduces the additional computing andstorage resources necessary to perform the data modification procedure.In some implementations, the data modification procedure is managed mytransaction management and access control module 228 (FIG. 2).Additionally, in some embodiments, the metadata is managed by, andaccessed through, configuration and metadata manager 222.

FIG. 9 is a flow diagram depicting an embodiment of a method 900 forcreating a temporary duplicate catalog object. Initially, method 900identifies an original catalog object associated with a set of data at902. In some embodiments, the original catalog object represents alogical grouping of data in a data storage system. The original catalogobject may include one or more of a table, a database, a schema, anaccount, a constraint, a file format, a function, a role, a sequence, astage, a column, a user, a volume, or other catalog objects. A duplicatecopy of the original catalog object is created at 904 without copyingthe data itself. In some embodiments, creating the duplicate copy of theoriginal catalog object includes copying metadata associated with theset of data to the duplicate catalog object. This metadata may includean inventory of data stored in the set of data and may identifyinformation regarding the set of data without requiring access to actualdata contained in the set of data. In particular implementations, theduplicate catalog object is read only. In some embodiments, theduplicate catalog object includes a duplicate hierarchy of allgenerations of children.

The method allows access 906 to the set of data using the duplicatecatalog object, where the data associated with the original catalogobject can be modified independently of the duplicate catalog object at908. In some embodiments, the modified data associated with the originalcatalog object is not visible to the duplicate catalog object. Further,the modified data associated with the duplicate catalog object may notbe visible to the original catalog object. In other embodiments, datadeleted from the original catalog object remains visible to theduplicate catalog object and data deleted from the duplicate catalogobject remains visible to the original catalog object. In particularimplementations, inserted data associated with the original catalogobject is not visible to the duplicate catalog object and inserted dataassociated with the duplicate catalog object is not visible to theoriginal catalog object. After modification of the data associated withthe original catalog object is complete, the duplicate catalog object isdeleted at 910. The creation of a duplicate catalog object withoutcopying the data itself can save significant time, bandwidth, andcomputing resources as compared to making a full copy of the originalcatalog object including all of the associated data.

FIGS. 10A-10D illustrate the cloning of tables. In the embodimentdepicted in FIGS. 10A-10D, each table contains a collection of multiplefiles. As described below, once a file is written it cannot be updatedor modified. If changes to the file are necessary, the file is deletedand replaced with a different file that contains the changes. If aparticular file is not in use, it may be deleted. The metadata discussedabove may include information regarding the relationship between thetable and the files associated with that table. This relationshipbetween the table and the files may also be referred to as a mapping ofthe files.

FIG. 10A illustrates an example table T1 with i files (labeled F1, F2 .. . Fi). FIG. 10B shows the result of a cloning of table T1 to create acloned table T2. In this embodiment, the cloning process copies themetadata from table T1 to the cloned table T2. As discussed herein,copying the metadata is much faster than copying all of the underlyingdata. FIG. 10B shows that both table T1 and table T2 are associated withthe same files immediately after the cloning process.

After cloned table T2 is created, new files can be added to either tableT1 or T2 independently of the other table. Additionally, files can bedeleted from either table T1 or T2 independently of the other table. Forexample, FIG. 10C shows the table and file associations after table T1deleted file F2 and added new file Fj. Deleted file F2 is still visibleto table T2, but new file Fj is not visible to table T2. In FIG. 10D,table T2 deleted file F1 and added new file Tk. File F1 remains visibleto table T1, but new file Tk is not visible to table T1.

Although FIGS. 10A-10D illustrate the cloning of tables, alternateembodiments may clone catalog objects, schemas and databases in asimilar manner. In particular embodiments, maps of all tables present ina schema are maintained as well as maps of all schemas present in adatabase. After cloning, the two schemas (or two databases) can bemodified independently of one another.

The cloning systems and methods discussed herein improve the periodicloading of (and analysis of) new data or experimental data.Additionally, these systems and methods support quick updates of newdata while requiring minimal additional computing or data storageresources.

FIG. 11 is a block diagram depicting an example computing device 1100.In some embodiments, computing device 1100 is used to implement one ormore of the systems and components discussed herein. For example,computing device 1100 may allow a user or administrator to accessresource manager 102. Further, computing device 1100 may interact withany of the systems and components described herein. Accordingly,computing device 1100 may be used to perform various procedures andtasks, such as those discussed herein. Computing device 1100 canfunction as a server, a client or any other computing entity. Computingdevice 1100 can be any of a wide variety of computing devices, such as adesktop computer, a notebook computer, a server computer, a handheldcomputer, a tablet, and the like.

Computing device 1100 includes one or more processor(s) 1102, one ormore memory device(s) 1104, one or more interface(s) 1106, one or moremass storage device(s) 1108, and one or more Input/Output (I/O)device(s) 1110, all of which are coupled to a bus 1112. Processor(s)1102 include one or more processors or controllers that executeinstructions stored in memory device(s) 1104 and/or mass storagedevice(s) 1108. Processor(s) 1102 may also include various types ofcomputer-readable media, such as cache memory.

Memory device(s) 1104 include various computer-readable media, such asvolatile memory (e.g., random access memory (RAM)) and/or nonvolatilememory (e.g., read-only memory (ROM)). Memory device(s) 1104 may alsoinclude rewritable ROM, such as Flash memory.

Mass storage device(s) 1108 include various computer readable media,such as magnetic tapes, magnetic disks, optical disks, solid statememory (e.g., Flash memory), and so forth. Various drives may also beincluded in mass storage device(s) 1108 to enable reading from and/orwriting to the various computer readable media. Mass storage device(s)1108 include removable media and/or non-removable media.

I/O device(s) 1110 include various devices that allow data and/or otherinformation to be input to or retrieved from computing device 1100.Example I/O device(s) 1110 include cursor control devices, keyboards,keypads, microphones, monitors or other display devices, speakers,printers, network interface cards, modems, lenses, CCDs or other imagecapture devices, and the like.

Interface(s) 1106 include various interfaces that allow computing device1100 to interact with other systems, devices, or computing environments.Example interface(s) 1106 include any number of different networkinterfaces, such as interfaces to local area networks (LANs), wide areanetworks (WANs), wireless networks, and the Internet.

Bus 1112 allows processor(s) 1102, memory device(s) 1104, interface(s)1106, mass storage device(s) 1108, and I/O device(s) 1110 to communicatewith one another, as well as other devices or components coupled to bus1112. Bus 1112 represents one or more of several types of busstructures, such as a system bus, PCI bus, IEEE 1394 bus, USB bus, andso forth.

For purposes of illustration, programs and other executable programcomponents are shown herein as discrete blocks, although it isunderstood that such programs and components may reside at various timesin different storage components of computing device 1100, and areexecuted by processor(s) 1102. Alternatively, the systems and proceduresdescribed herein can be implemented in hardware, or a combination ofhardware, software, and/or firmware. For example, one or moreapplication specific integrated circuits (ASICs) can be programmed tocarry out one or more of the systems and procedures described herein.

Although the present disclosure is described in terms of certainpreferred embodiments, other embodiments will be apparent to those ofordinary skill in the art, given the benefit of this disclosure,including embodiments that do not provide all of the benefits andfeatures set forth herein, which are also within the scope of thisdisclosure. It is to be understood that other embodiments may beutilized, without departing from the scope of the present disclosure.

The invention claimed is:
 1. A system comprising: means for identifyinga catalog object in a database comprising data stored in files, whereinthe files cannot be updated or modified; means for creating a duplicatecopy of the catalog object without copying the data itself; means formodifying at least one of the files of the catalog object by recreatingthe at least one of the files; means for executing data access requestsdirected to the data stored in the files by reading the duplicate copyof the catalog object when the at least one of the files is beingrecreated; means for adding additional files to either of the catalogobject or the duplicate copy of the catalog object independently ofanother; and means for deleting the duplicate copy of the catalog objectupon completion of modifying the at least one of the files of thecatalog object.
 2. The system of claim 1, wherein the means for creatinga duplicate copy of the catalog object further comprises means forcopying metadata associated with the data stored in the files.
 3. Thesystem of claim 2, wherein the means for copying metadata furthercomprises means for copying an inventory of the data stored in thefiles.
 4. The system of claim 2, wherein the means for copying metadatafurther comprises means for copying information regarding the datastored in the files that enables identification of the data stored inthe files without requiring access to the data.
 5. The system of claim1, wherein the means for identifying a catalog object in a databasecomprises means for identifying a logical grouping of data in thedatabase.
 6. The system of claim 1, wherein the means for identifying acatalog object comprises means for identifying one of a table, adatabase, a schema, an account, a constraint, a file format, a function,a role, a sequence, a stage, a column, a user, or a volume.
 7. Thesystem of claim 1, wherein the means for modifying at least one of thefiles of the catalog object further comprises means for modifying suchthat modified data is not visible to the duplicate copy of the catalogobject.
 8. The system of claim 1, wherein the means for modifying atleast one of the files of the catalog object further comprises means formodifying such that modified data is not visible to the catalog objectin the database.
 9. A system for cloning objects within a database, thesystem comprising: a storage platform configured to store originalobjects associated with a set of data; and a resource manager configuredto: identify a catalog object in the database, the catalog objectcomprising data stored in files, wherein the files cannot be updated ormodified; create a duplicate copy of the catalog object without copyingthe data itself; allow modification of at least one of the files of thecatalog object by recreating the at least one of the files; assign tasksfor executing data access requests directed to the data stored in thefiles, the tasks comprising reading the duplicate copy of the catalogobject when the at least one of the files is being recreated; addadditional files to either of the catalog object or the duplicate copyof the catalog object independently of another; and delete the duplicatecopy of the catalog object upon completion of modification of the atleast one of the files of the catalog object.
 10. The system of claim 9,wherein the resource manager is further configured to copy metadataassociated with the data stored in the files.
 11. The system of claim10, wherein the metadata includes an inventory of the data stored in thefiles.
 12. The system of claim 10, wherein the metadata identifiesinformation regarding the data stored in the files such that the datastored in the files can be identified without reading the data itself.13. The system of claim 9, wherein the catalog object comprises alogical grouping of data in the database.
 14. The system of claim 9,wherein the catalog object comprises one or more of a table, a database,a schema, an account, a constraint, a file format, a function, a role, asequence, a stage, a column, a user, or a volume.
 15. The system ofclaim 9, wherein modification of the at least one of the files comprisesmodifying such that modified data is not visible to the duplicate copyof the catalog object.
 16. The system of claim 9, wherein modificationof the at least one of the files comprises modifying such that modifieddata associated with the duplicate objects is not visible to the catalogobject in the database.
 17. A method comprising: identifying a catalogobject in a database, the catalog object comprising data stored infiles, wherein the files cannot be updated or modified; creating aduplicate copy of the catalog object without copying the data itself;modifying at least one of the files of the catalog object by recreatingthe at least one of the files; executing data access requests directedto the data stored in the files by reading the duplicate copy of thecatalog object when the at least one of the files is being recreated;adding additional files to either of the catalog object or the duplicatecopy of the catalog object independently of another; and deleting theduplicate copy of the catalog object upon completion of modifying the atleast one of the files of the catalog object.
 18. The method of claim17, wherein creating a duplicate copy of the catalog object furthercomprises copying metadata associated with the data stored in the files.19. The method of claim 18, wherein creating a duplicate copy of thecatalog object further comprises copying an inventor of the data storedin the files.
 20. The method of claim 18, wherein the metadata comprisesinformation about the data stored in the files such that the data storedin the files can be identified without reading the data itself.
 21. Themethod of claim 17, wherein identifying the catalog object comprisesidentifying a logical grouping of data in a data in the database. 22.The method of claim 17, wherein identifying the catalog object comprisesidentifying one or more of a table, a database, a schema, an account, aconstraint, a file format, a function, a role, a sequence, a stage, acolumn, a user, or a volume.
 23. The method of claim 17, whereincreating the duplicate copy of the catalog object comprises creating theduplicate copy such that the duplicate copy is read only.
 24. The methodof claim 17, wherein modifying the at least one of the files of thecatalog object comprises modifying such that modified data is notvisible to the duplicate copy of the catalog object.
 25. The method ofclaim 17, wherein modifying the at least one of the files of the catalogobject comprises modifying such that modified data is not visible to thecatalog object in the database.
 26. The method of claim 17, whereincreating the duplicate copy of the catalog object comprises creating theduplicate copy such that the data deleted from the data stored in thefiles remains visible to the duplicate copy of the catalog object. 27.The method of claim 17, wherein creating the duplicate copy of thecatalog object comprises creating such that data deleted from theduplicate copy of the catalog object remains visible to the data storedin the files of the database.
 28. The method of claim 17, whereinmodifying the at least one of the files of the catalog object comprisesmodifying such that data added to the data stored in the files is notvisible to the duplicate copy of the catalog object.
 29. The method ofclaim 17, further comprising modifying the duplicate copy of the catalogobject such that data inserted into the duplicate copy of the catalogobject is not visible to the data stored in the files of the database.30. The method of claim 17, further comprising deleting data originallystored in the files upon completion of modifying the at least one of thefiles of the catalog object.
 31. The method of claim 17, whereincreating the duplicate copy of the catalog object further comprisesupdating a duplicate hierarchy of all generations of children.